app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/addlink/AddLinkScreen.kt (1)

139-145: Auto-fetch has no cancellation of in-flight requests and no debounce.

fetchMetadata is a plain lambda (not a suspend function), so when deeprInfo.link changes and LaunchedEffect restarts, the previously fired viewModel.fetchMetaData() call is not cancelled. If the link changes rapidly (e.g., QR scan immediately followed by a manual edit), stale callbacks can overwrite the current metadata.

Consider making fetchMetaData a suspend function invoked directly inside the LaunchedEffect coroutine (so it's automatically cancelled on re-key), or track/ignore stale responses by comparing the link at callback time.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/addlink/AddLinkScreen.kt`
around lines 139 - 145, The LaunchedEffect block starts new work on
deeprInfo.link but calls a non-cancellable callback (fetchMetadata /
viewModel.fetchMetaData), causing stale responses to overwrite newer state;
change the implementation so the metadata fetch is cancellable or ignores stale
results: either convert fetchMetadata (and underlying viewModel.fetchMetaData)
into a suspend function and call it directly inside the LaunchedEffect coroutine
(so coroutine cancellation will abort in-flight work), or add a request token
(capture the current normalized link or a UUID in LaunchedEffect) and have the
fetch callback verify that the token/link still matches before applying results
(compare against deeprInfo.link or the captured token in the callback). Ensure
you update references to normalizeLink, isValidDeeplink, fetchMetadata, and
viewModel.fetchMetaData accordingly so only the latest request can update UI.

app/src/main/java/com/yogeshpaliyal/deepr/MainActivity.kt (2)

200-200: Missing DisposableEffect import; stale LaunchedEffect import

DisposableEffect is invoked via its fully qualified name (androidx.compose.runtime.DisposableEffect) rather than being imported like every other Compose API in this file. At the same time, the old import androidx.compose.runtime.LaunchedEffect at line 24 appears unused after this refactor.

♻️ Proposed fix

+import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect

Then on line 200:

-    androidx.compose.runtime.DisposableEffect(Unit) {
+    DisposableEffect(Unit) {

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/MainActivity.kt` at line 200, File
uses androidx.compose.runtime.DisposableEffect with a fully-qualified name and
still has an unused import for LaunchedEffect; replace the fully-qualified call
with a proper import and remove the stale import. Add "import
androidx.compose.runtime.DisposableEffect" to the imports, remove "import
androidx.compose.runtime.LaunchedEffect" if unused, and update any usages (e.g.,
the call currently written as androidx.compose.runtime.DisposableEffect(Unit) {
... }) to use the imported DisposableEffect symbol so imports are consistent and
no unused LaunchedEffect remains.

---

203-226: Extract duplicated clipboard-reading logic into a shared helper lambda

The listener body (lines 203–213) and the initial check (lines 217–226) are byte-for-byte identical. Even after applying the getPrimaryClipDescription() guard above, both blocks will remain duplicated.

♻️ Proposed refactor

+    val processClip = {
+        val description = clipboard.primaryClipDescription
+        if (description != null && description.hasMimeType(android.content.ClipDescription.MIMETYPE_TEXT_PLAIN)) {
+            val clipData = clipboard.primaryClip
+            if (clipData != null && clipData.itemCount > 0) {
+                val text = clipData.getItemAt(0).text?.toString()
+                if (!text.isNullOrBlank()) {
+                    val normalizedLink = normalizeLink(text)
+                    if (isValidDeeplink(normalizedLink)) {
+                        clipboardLink = ClipboardLink(normalizedLink)
+                    }
+                }
+            }
+        }
+    }
+
-    val listener = ClipboardManager.OnPrimaryClipChangedListener {
-        val clipData = clipboard.primaryClip
-        ...
-    }
+    val listener = ClipboardManager.OnPrimaryClipChangedListener { processClip() }

-    // Initial check
-    val clipData = clipboard.primaryClip
-    ...
+    // Initial check
+    processClip()

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/MainActivity.kt` around lines 203 -
226, The clipboard-reading logic is duplicated between the
ClipboardManager.OnPrimaryClipChangedListener block and the initial check;
extract that shared code into a single helper (either a private function or a
lambda) — e.g., create a processClipboard() function that reads
clipboard.primaryClip, gets text, calls normalizeLink(text), checks
isValidDeeplink(normalizedLink) and assigns clipboardLink =
ClipboardLink(normalizedLink) — then call that helper from the listener body and
from the initial check so ClipboardManager.OnPrimaryClipChangedListener,
normalizeLink, isValidDeeplink, ClipboardLink and clipboard are reused without
duplication.

app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/TransferLinkLocalServer.kt (1)

45-45: Optional: import QrCodeColors instead of using its fully qualified name.

QrCodeView is imported at Line 59, but QrCodeColors is referenced with its fully qualified class name inline. Adding an import keeps the call-site consistent and easier to read.

♻️ Proposed change

 import com.lightspark.composeqr.QrCodeView
+import com.lightspark.composeqr.QrCodeColors

-                colors =
-                    com.lightspark.composeqr.QrCodeColors(
-                        background = Color.White,
-                        foreground = Color.Black,
-                    ),
+                colors =
+                    QrCodeColors(
+                        background = Color.White,
+                        foreground = Color.Black,
+                    ),

Also applies to: 323-327

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/TransferLinkLocalServer.kt`
at line 45, Replace the fully-qualified QrCodeColors usages with a simple
import: add an import for QrCodeColors at the top of the file and update all
call-sites (the places where QrCodeView is used and the occurrences around the
previous lines 323-327) to reference QrCodeColors directly instead of its
fully-qualified name; this keeps the import style consistent with QrCodeView and
improves readability.

app/src/main/java/com/yogeshpaliyal/deepr/ui/components/NoteViewDialog.kt (1)

91-104: Migrate from deprecated ClickableText to BasicText with LinkAnnotation.

ClickableText is deprecated as of Compose Foundation 1.7.0-alpha07, and your project's Compose BOM (2025.09.00) is well past this point. Replace the StringAnnotation("URL", ...) offset-lookup pattern with BasicText + LinkAnnotation.Clickable using withLink() in buildAnnotatedString. Pass LinkInteractionListener to LinkAnnotation.Clickable to retain the custom openDeeplink() dispatch.

Migration sketch

-import androidx.compose.foundation.text.ClickableText
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.ui.text.LinkAnnotation
+import androidx.compose.ui.text.TextLinkStyles
+import androidx.compose.ui.text.withLink

 val annotatedString = buildAnnotatedString {
     val text = deepr.notes
-    append(text)
     val matcher = Patterns.WEB_URL.matcher(text)
+    var cursor = 0
     while (matcher.find()) {
+        append(text.substring(cursor, matcher.start()))
         val url = text.substring(matcher.start(), matcher.end())
-        addStringAnnotation(tag = "URL", annotation = url, start = matcher.start(), end = matcher.end())
-        addStyle(SpanStyle(color = primaryColor, textDecoration = TextDecoration.Underline), start = matcher.start(), end = matcher.end())
+        withLink(
+            LinkAnnotation.Clickable(
+                tag = url,
+                styles = TextLinkStyles(SpanStyle(color = primaryColor, textDecoration = TextDecoration.Underline)),
+                linkInteractionListener = { openDeeplink(context, url) }
+            )
+        ) { append(url) }
+        cursor = matcher.end()
     }
+    append(text.substring(cursor))
 }

 SelectionContainer {
-    ClickableText(
+    BasicText(
         text = annotatedString,
         style = MaterialTheme.typography.bodyLarge.copy(color = MaterialTheme.colorScheme.onSurface),
-        onClick = { offset ->
-            annotatedString.getStringAnnotations(tag = "URL", start = offset, end = offset)
-                .firstOrNull()?.let { openDeeplink(context, it.item) }
-        },
     )
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/ui/components/NoteViewDialog.kt`
around lines 91 - 104, Replace the deprecated ClickableText usage by building
annotatedString with LinkAnnotation.Clickable via withLink() in
buildAnnotatedString and render it with BasicText; update the annotation
creation code where you currently use StringAnnotation("URL", ...) so it uses
withLink(url) / LinkAnnotation.Clickable and attach a LinkInteractionListener
that calls openDeeplink(context, url) (preserve the existing annotatedString
variable name and the openDeeplink dispatch logic), then replace the
ClickableText block (which performs getStringAnnotations and offset lookup) with
a BasicText that uses the new annotatedString and the LinkAnnotation.Clickable
listener to handle taps.

app/src/main/sqldelight/com/yogeshpaliyal/deepr/Deepr.sq (1)

218-220: Stray blank line between GROUP BY and ORDER BY is inconsistent with all other queries in this file.

SQLDelight's parser treats this as harmless whitespace, but every other multi-line query in Deepr.sq has no blank lines mid-body. Remove line 219 for consistency.

♻️ Proposed cleanup

 GROUP BY Tags.id, Tags.name
-
 ORDER BY linkCount DESC, Tags.name;

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/sqldelight/com/yogeshpaliyal/deepr/Deepr.sq` around lines 218 -
220, Remove the stray blank line between the GROUP BY clause and the ORDER BY
clause so the query remains consistent with others in the file; specifically,
join "GROUP BY Tags.id, Tags.name" and "ORDER BY linkCount DESC, Tags.name" with
no blank line between them (the relevant symbols to locate are GROUP BY,
Tags.id, Tags.name, ORDER BY, and linkCount).

app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/TagSelectionScreen.kt (1)

692-709: split(tag.name) loses trailing content when the name occurs more than once in the formatted string.

If the user somehow names a tag with a value that appears multiple times in the resolved format string, parts.size > 2 and only parts[0] + bold + parts[1] is rendered — content after the second occurrence is silently dropped. While the current delete_tag_confirmation_with_name has a single %s, this is fragile for future copy changes. Using indexOf is more robust.

♻️ Robust AnnotatedString construction via indexOf

-val fullMessage = stringResource(R.string.delete_tag_confirmation_with_name, tag.name)
-val parts = fullMessage.split(tag.name)
-val annotatedString = buildAnnotatedString {
-    if (parts.size >= 2) {
-        append(parts[0])
-        withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
-            append(tag.name)
-        }
-        append(parts[1])
-    } else {
-        append(fullMessage)
-    }
-}
+val fullMessage = stringResource(R.string.delete_tag_confirmation_with_name, tag.name)
+val annotatedString = buildAnnotatedString {
+    val startIndex = fullMessage.indexOf(tag.name)
+    if (startIndex != -1) {
+        append(fullMessage.substring(0, startIndex))
+        withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+            append(tag.name)
+        }
+        append(fullMessage.substring(startIndex + tag.name.length))
+    } else {
+        append(fullMessage)
+    }
+}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/TagSelectionScreen.kt`
around lines 692 - 709, The current construction in TagSelectionScreen.kt builds
annotatedString by splitting fullMessage with tag.name (variables fullMessage,
tag.name, parts, annotatedString), which drops content after the second
occurrence; instead find the first occurrence using indexOf(tag.name), then
append substring before, append the tag name with bold SpanStyle, and append the
remainder (substring after first match) so any further occurrences are
preserved; update buildAnnotatedString usage accordingly and keep the Text(...)
rendering as-is.

app/src/main/java/com/yogeshpaliyal/deepr/server/LocalServerRepositoryImpl.kt (2)

107-107: Redundant val port = port — no-op self-assignment

This creates a local val that shadows the function parameter with its own value. It serves no purpose and may generate a compiler warning.

✏️ Proposed fix

-        val port = port
-
         server = embeddedServer(CIO, host = "0.0.0.0", port = port) {

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@app/src/main/java/com/yogeshpaliyal/deepr/server/LocalServerRepositoryImpl.kt`
at line 107, Remove the redundant local shadowing of the parameter by deleting
the line "val port = port" in LocalServerRepositoryImpl (the local variable
shadows the function parameter named port); just use the existing parameter
"port" directly everywhere in the function (or rename if you intended a
different variable), ensuring no other code relies on that local declaration.

---

386-402: POST /api/links/increment-count reads the resource ID from a query parameter

Using a query parameter for a mutable state change on a POST endpoint is non-idiomatic (query params belong on GET/safe methods). The conventional REST design is either POST /api/links/{id}/increment-count (path parameter) or PATCH /api/links/{id} with a body. This also makes the endpoint easier to document and harder to accidentally call via a GET proxy.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@app/src/main/java/com/yogeshpaliyal/deepr/server/LocalServerRepositoryImpl.kt`
around lines 386 - 402, Change the POST handler that currently reads the link id
from call.request.queryParameters in the route "/api/links/increment-count" to
accept the id as a path parameter (e.g. POST "/api/links/{id}/increment-count")
or accept a JSON body with an id, then parse that value instead of using
queryParameters; update the route declaration and replace
call.request.queryParameters["id"]?.toLongOrNull() with code that retrieves the
id from call.parameters["id"] or from the request body, and continue calling
accountViewModel.incrementOpenedCount(id) and responding with
SuccessResponse/ErrorResponse as before.

app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/Home.kt (3)

1596-1607: Fragile annotated-string construction: split(profile.name) can break for certain names or locales.

If profile.name is a short/common substring (e.g., "a", "de"), split may fragment the translated message at unintended positions. Also, if the name appears more than once in the message, parts.size >= 2 is true but parts[1] won't contain the full trailing text.

A more robust approach is to locate the name's position in the formatted string and split only at that known offset:

Proposed fix

-                    val parts = fullMessage.split(profile.name)
-                    val annotatedString = buildAnnotatedString {
-                        if (parts.size >= 2) {
-                            append(parts[0])
-                            withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
-                                append(profile.name)
-                            }
-                            append(parts[1])
-                        } else {
-                            append(fullMessage)
-                        }
-                    }
+                    val annotatedString = buildAnnotatedString {
+                        val nameIndex = fullMessage.indexOf(profile.name)
+                        if (nameIndex >= 0) {
+                            append(fullMessage.substring(0, nameIndex))
+                            withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                                append(profile.name)
+                            }
+                            append(fullMessage.substring(nameIndex + profile.name.length))
+                        } else {
+                            append(fullMessage)
+                        }
+                    }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/Home.kt` around
lines 1596 - 1607, The annotated-string construction is fragile because
split(profile.name) can incorrectly fragment translations or handle multiple
occurrences; instead, find the first occurrence index of profile.name in the
formatted fullMessage (use fullMessage.indexOf(profile.name)) and if index >= 0
build the AnnotatedString by taking fullMessage.substring(0, index), append the
bold profile.name, then append fullMessage.substring(index +
profile.name.length), otherwise fall back to appending fullMessage; update the
logic around fullMessage, parts, and annotatedString in Home.kt to use this
index-based splitting so only the intended occurrence is made bold.

---

1688-1690: Save button enabled check should compare trimmed names for consistent UX.

enabled = newName.isNotBlank() && newName != profile.name allows enabling Save when only leading/trailing whitespace differs (e.g., " Default " vs "Default"), but the onClick handler trims before comparing, resulting in a "name already exists" error after the user clicks.

Proposed fix

-                    enabled = newName.isNotBlank() && newName != profile.name
+                    enabled = newName.isNotBlank() && newName.trim() != profile.name

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/Home.kt` around
lines 1688 - 1690, The Save button's enabled check uses raw newName and
profile.name, allowing only-whitespace differences to enable the button but
failing later because onClick trims; update the enabled logic to compare trimmed
values instead (use newName.trim().isNotBlank() and compare newName.trim() with
profile.name.trim() or the canonical stored name) so the enabled state matches
the onClick trimming behavior; locate the Save button enabled assignment
(enabled = newName.isNotBlank() && newName != profile.name) and change it to use
trimmed comparisons consistent with the onClick handler.

---

569-613: FAB tap/long-press via inner pointerInput bypasses the FAB's ripple and accessibility semantics.

The FloatingActionButton(onClick = {}) has an empty click handler while actual tap handling is done via detectTapGestures on the inner Box. This means the FAB's Material ripple effect and accessibility click action may not behave as expected — the inner pointerInput consumes the gesture before the FAB's clickable modifier processes it.

Consider using combinedClickable (from foundation) on the FAB's modifier instead, which natively supports both onClick and onLongClick while preserving ripple and semantics:

Sketch of alternative approach

-            if (!showProfilesGrid) {
-                FloatingActionButton(
-                    onClick = {},
-                ) {
-                    Box(
-                        modifier =
-                            Modifier
-                                .size(56.dp)
-                                .pointerInput(Unit) {
-                                    detectTapGestures(
-                                        onTap = {
-                                            localNavigator.add(AddLinkScreen(createDeeprObject()))
-                                        },
-                                        onLongPress = {
-                                            hapticFeedback.performHapticFeedback(HapticFeedbackType.LongPress)
-                                            // ... clipboard logic ...
-                                            localNavigator.add(AddLinkScreen(createDeeprObject(link = linkToPass)))
-                                        },
-                                    )
-                                },
-                        contentAlignment = Alignment.Center,
-                    ) {
-                        Icon(
-                            TablerIcons.Plus,
-                            contentDescription = stringResource(R.string.add_link),
-                        )
-                    }
-                }
+            if (!showProfilesGrid) {
+                FloatingActionButton(
+                    onClick = {
+                        localNavigator.add(AddLinkScreen(createDeeprObject()))
+                    },
+                    modifier = Modifier.combinedClickable(
+                        onClick = {
+                            localNavigator.add(AddLinkScreen(createDeeprObject()))
+                        },
+                        onLongClick = {
+                            hapticFeedback.performHapticFeedback(HapticFeedbackType.LongPress)
+                            // ... clipboard logic ...
+                            localNavigator.add(AddLinkScreen(createDeeprObject(link = linkToPass)))
+                        },
+                    ),
+                ) {
+                    Icon(
+                        TablerIcons.Plus,
+                        contentDescription = stringResource(R.string.add_link),
+                    )
+                }

app/src/main/java/com/yogeshpaliyal/deepr/viewmodel/AccountViewModel.kt (2)

849-857: getMaxPriority() + insertProfile(name, maxPriority + 1) is not atomic.

If two profile insertions run concurrently, both can read the same max priority and insert with the same value. Low risk since this is UI-driven (single FAB), but worth noting.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/viewmodel/AccountViewModel.kt`
around lines 849 - 857, The current insertProfile in AccountViewModel uses
linkRepository.getMaxPriority() and then linkRepository.insertProfile(name,
maxPriority + 1) separately, which is not atomic and can cause duplicate
priorities under concurrency; change this by adding a single atomic
repository/DAO operation (e.g.,
linkRepository.insertProfileWithNextPriority(name) or a DAO method annotated
with `@Transaction`) that reads the current max priority and inserts the new
profile inside the same transaction, then call that new method from
AccountViewModel.insertProfile instead of calling getMaxPriority and
insertProfile separately; alternatively, if you prefer in-memory serialization,
guard the two calls with a dedicated Mutex/synchronized block in the repository
so the read+insert cannot interleave.

---

141-148: normalizePriorities() rewrites every profile's priority on every app launch and every move.

On init (line 136), this runs unconditionally for existing profiles, issuing up to N update queries. On each move, it runs again before the swap. For a small number of profiles this is tolerable, but consider tracking whether normalization is actually needed (e.g., a dirty flag or checking if priorities are already sequential) to avoid unnecessary DB writes on every cold start.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/viewmodel/AccountViewModel.kt`
around lines 141 - 148, normalizePriorities() currently issues updates for every
profile on init and before moves; change it to detect whether normalization is
required and only perform writes when priorities are out of order or a "dirty"
flag is set. Specifically, in normalizePriorities() (and where it is called)
first load profiles with linkRepository.getAllProfiles().executeAsList() and
check if any profile.priority != index.toLong()—if none mismatch, return early;
alternatively, add a persistent or in-memory dirty flag that is set when
profiles are added/removed/moved (e.g., in your move/swap methods) and only run
updateProfilePriority(profile.id, index.toLong()) when the flag is true, then
clear the flag after successful normalization. Ensure callers (init and move)
use the new check/flag to avoid unconditional DB writes.

app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/Home.kt (1)

499-499: ⚠️ Potential issue | 🟡 Minor

Localize the remaining reorder content descriptions.

Line [499], Line [927], and Line [941] still use hardcoded English strings ("Finish Reordering", "Move Up", "Move Down"), which breaks localization/accessibility consistency.

Proposed fix

-                                        contentDescription = if (isReordering) "Finish Reordering" else stringResource(R.string.reorder),
+                                        contentDescription =
+                                            if (isReordering) stringResource(R.string.finish_reordering)
+                                            else stringResource(R.string.reorder),
...
-                                            contentDescription = "Move Up",
+                                            contentDescription = stringResource(R.string.move_up),
...
-                                            contentDescription = "Move Down",
+                                            contentDescription = stringResource(R.string.move_down),

Also applies to: 927-927, 941-941

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/Home.kt` at line
499, The contentDescription values are using hardcoded English strings; update
them to use string resources so they're localizable — replace the literal
"Finish Reordering" in the contentDescription expression that checks
isReordering with stringResource(R.string.finish_reordering) (or equivalent),
and replace "Move Up" and "Move Down" usages with
stringResource(R.string.move_up) and stringResource(R.string.move_down)
respectively; locate these in Home.kt where contentDescription is passed (the
composable using isReordering and the up/down buttons) and ensure the
corresponding string resource keys are added to strings.xml.

app/src/main/res/values-it/strings.xml (2)

257-257: ⚠️ Potential issue | 🟡 Minor

Use the standard Italian imperative for reorder.

Line 257 still uses “Reordina”; the standard UI imperative is “Riordina”.

✏️ Suggested fix

-    <string name="reorder">Reordina</string>
+    <string name="reorder">Riordina</string>

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/res/values-it/strings.xml` at line 257, The string resource
named "reorder" currently uses the non-standard Italian form "Reordina"; update
the value of the resource with name "reorder" to the standard imperative
"Riordina" so the UI uses the correct Italian wording.

---

273-273: ⚠️ Potential issue | 🟡 Minor

Fix unresolved Italian punctuation/elision issues.

Line 273 is missing the terminal period, and Line 327 should use “nell'aggiunta” (apostrophe required).

✏️ Suggested fix

-    <string name="profile_delete_confirmation_with_name">Sei sicuro di voler eliminare il profilo %s? Tutti i link e le etichette in questo profilo verranno eliminati</string>
+    <string name="profile_delete_confirmation_with_name">Sei sicuro di voler eliminare il profilo %s? Tutti i link e le etichette in questo profilo verranno eliminati.</string>

-    <string name="web_error_add_link">Errore nell aggiunta del link. Riprova.</string>
+    <string name="web_error_add_link">Errore nell'aggiunta del link. Riprova.</string>

Also applies to: 327-327

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/res/values-it/strings.xml` at line 273, The Italian strings have
punctuation and elision issues: add a terminal period to the string with name
profile_delete_confirmation_with_name and fix the other affected string to use
the elided form "nell'aggiunta" (include the apostrophe) — locate the string
resource profile_delete_confirmation_with_name and append a final period, and
locate the other Italian string (line ~327) and replace its word with
"nell'aggiunta" to correct the apostrophe/elision.

app/src/main/res/values/strings.xml (1)

272-273: ⚠️ Potential issue | 🟡 Minor

Clean up profile-delete confirmation strings.

Line 272 is missing terminal punctuation and reads awkwardly; Line 273 duplicates Line 271 and adds localization maintenance overhead.

✏️ Suggested fix

-    <string name="profile_delete_confirmation_with_name">Are you sure you want to delete %s profile? All links and tags in this profile will be deleted</string>
-    <string name="delete_profile_confirmation">Are you sure you want to delete this profile? All links and tags in this profile will be deleted.</string>
+    <string name="profile_delete_confirmation_with_name">Are you sure you want to delete '%s' profile? All links and tags in this profile will be deleted.</string>

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/res/values/strings.xml` around lines 272 - 273, Update the two
string resources to remove duplication and fix punctuation/grammar: eliminate
the redundant delete_profile_confirmation entry and standardize on a single,
well-formed resource (profile_delete_confirmation_with_name) whose text includes
proper terminal punctuation and reads smoothly when a profile name is inserted
(adjust "%s profile" wording to "%s profile?" or better "%s profile." as
appropriate); ensure the final string resource name remains unique
(profile_delete_confirmation_with_name) and update any callers to use that
resource.

app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/Home.kt (1)

838-842: Avoid O(n²) index lookup in ProfilesGrid.

Line [841] uses profiles.indexOf(profile) inside item rendering; this adds linear lookup per item. Use indexed items directly.

Proposed refactor

+import androidx.compose.foundation.lazy.grid.itemsIndexed
...
-            items(profiles, key = { it.id }) { profile ->
+            itemsIndexed(profiles, key = { _, profile -> profile.id }) { index, profile ->
                 val isSelected = profile.id == currentProfileId
                 val hapticFeedback = LocalHapticFeedback.current
-                val index = profiles.indexOf(profile)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@app/src/main/java/com/yogeshpaliyal/deepr/ui/screens/home/Home.kt` around
lines 838 - 842, The code in the items(...) block does an O(n) lookup with
profiles.indexOf(profile) for every item; change the Lazy/Compose items call to
an indexed variant so the index is provided directly (e.g., use itemsIndexed
with key = { index, profile -> profile.id } and the lambda signature (index,
profile) -> ...), then remove the profiles.indexOf(profile) call and use the
provided index; keep existing uses of currentProfileId,
LocalHapticFeedback.current, and isSelected as before.

Configuration used: defaults

Review profile: CHILL

Plan: Pro